home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 19 / CU Amiga Magazine's Super CD-ROM 19 (1998)(EMAP Images)(GB)[!][issue 1998-02].iso / CUCD / Programming / LEDA / incl / LEDA.020+881 / array.h < prev    next >
C/C++ Source or Header  |  1994-08-05  |  3KB  |  114 lines
  1. /*******************************************************************************
  2. +
  3. +  LEDA  3.1c
  4. +
  5. +
  6. +  array.h
  7. +
  8. +
  9. +  Copyright (c) 1994  by  Max-Planck-Institut fuer Informatik
  10. +  Im Stadtwald, 6600 Saarbruecken, FRG     
  11. +  All rights reserved.
  12. + 
  13. *******************************************************************************/
  14.  
  15.  
  16. #ifndef LEDA_ARRAY_H
  17. #define LEDA_ARRAY_H
  18.  
  19. //------------------------------------------------------------------------------
  20. // arrays
  21. //------------------------------------------------------------------------------
  22.  
  23. #include <LEDA/impl/gen_array.h>
  24.  
  25. #if defined(LEDA_CHECKING_OFF)
  26. #define ARRAY_ACCESS(type)\
  27. type& operator[](int x)       { return ACCESS(type,v[x-Low]); }\
  28. type  operator[](int x) const { return ACCESS(type,v[x-Low]); }
  29. #else
  30. #define ARRAY_ACCESS(type)\
  31. type& operator[](int x)       { return ACCESS(type,(GenPtr&)entry(x));}\
  32. type  operator[](int x) const { return ACCESS(type,inf(x));}
  33. #endif
  34.  
  35.  
  36.  
  37. template<class type> 
  38.  
  39. class _CLASSTYPE array : public gen_array {
  40.  
  41. type X;
  42.  
  43. int cmp(GenPtr x, GenPtr y) const
  44.                         { return compare(ACCESS(type,x),ACCESS(type,y)); }
  45. void print_el(GenPtr& x,ostream& out) const { Print(ACCESS(type,x),out);}
  46. void read_el(GenPtr& x,istream& in)         { Read(X,in); x = Copy(X); }
  47. void clear_entry(GenPtr& x)  { Clear(ACCESS(type,x)); }
  48. void copy_entry(GenPtr& x)   { x = Copy(ACCESS(type,x));  }
  49. void init_entry(GenPtr& x)   { Init(X); x = Copy(X); }
  50.  
  51. int  int_type() const { return INT_TYPE(type); }
  52.  
  53. public:
  54. array()  {}
  55. array(int n)                : gen_array(n)   { init(); }
  56. array(int a, int b)         : gen_array(a,b) { init(); }
  57. array(const array<type>& A) : gen_array(A)   {}
  58. ~array()  { clear(); }
  59.  
  60. array<type>& operator=(const array<type>& A) 
  61. { return (array<type>&) gen_array::operator=(A); }
  62.  
  63. ARRAY_ACCESS(type)
  64.  
  65. void sort(int (*f)(const type&,const type&)) 
  66. { gen_array::sort(low(),high(),CMP_PTR(f));}
  67.  
  68. void sort(int (*f)(const type&,const type&), int l, int h)
  69. { gen_array::sort(l,h,CMP_PTR(f)); }
  70.  
  71. void sort()                      { gen_array::sort(low(),high(),0); }
  72. void sort(int l, int h)          { gen_array::sort(l,h,0); }
  73.  
  74. int binary_search(int (*f)(const type&,const type&), type x)
  75.                { return gen_array::binary_search(Convert(x),CMP_PTR(f));}
  76. int binary_search(type x)   
  77. { return (int_type()) ? gen_array::int_binary_search(Convert(x))
  78.                       : gen_array::binary_search(Convert(x));
  79.  }
  80.  
  81. };
  82.  
  83.  
  84.  
  85. /*------------------------------------------------------------------------*/
  86. /* 2 dimensional arrays                                                   */
  87. /*------------------------------------------------------------------------*/
  88.  
  89.  
  90. template<class type> 
  91.  
  92. class _CLASSTYPE array2 : public gen_array2 {
  93.  
  94. type X;
  95.  
  96. void clear_entry(GenPtr& x) { Clear(ACCESS(type,x)); }
  97. void copy_entry(GenPtr& x)  { x = Copy(ACCESS(type,x));  }
  98. void init_entry(GenPtr& x)  { Init(X); x = Copy(X); }
  99.  
  100. public:
  101.  
  102. type& operator()(int i, int j)       { return ACCESS(type,row(i)->entry(j)); }
  103. /*
  104. type  operator()(int i, int j) const { return ACCESS(type,row(i)->entry(j)); }
  105. */
  106.  
  107.  array2(int a,int b,int c,int d) :gen_array2(a,b,c,d){ init(a,b,c,d);}
  108.  array2(int n,int m)             :gen_array2(n,m)    { init(0,n-1,0,m-1);}
  109. ~array2() { clear(); }
  110. };
  111.  
  112.  
  113. #endif
  114.